package py.edu.ucom.poo.waterloo.agente;
import java.util.Random;

import py.edu.ucom.poo.waterloo.*;

/**
*
* @author WaterlooTeam
* En esta clase esta la logica de como juega un agente
*@version 1.0 Beta
*/
public abstract class Agente {
protected Ficha[] ficha;
protected Tablero mapaInterno;
protected static final int POSITIVO=1;
protected static final int NEGATIVO=-1;
protected Estado[] estados;
protected int contadorDeLosTablerosEstados=0;
protected int color;
protected SandBoxInterface sandBoxInterface;

public Agente(){
	mapaInterno = new Tablero();
	estados=new Estado[100];
}


public int getContadorDeLosTablerosEstados() {
	return contadorDeLosTablerosEstados;
}
public void setContadorDeLosTablerosEstados(int aumento) {
	this.contadorDeLosTablerosEstados = contadorDeLosTablerosEstados+aumento;
}

public int getColor() {
	return color;
}
public void setColor(int color) {
	this.color = color;
}

public Ficha[] getFicha() {
	return ficha;
}
public void setFicha(Ficha[] ficha) {
	this.ficha = ficha;
}
public Tablero getMapaInterno() {
	return mapaInterno;
}
public void setMapaInterno(Tablero mapaInterno) {
	this.mapaInterno = mapaInterno;
}
/**
*
* @param f recibe un array de fichas para poder ubicar las fichas en el tablero
* @param t recibe un tablero aparentemente al pedo
* @return tablero, retorna un tablero con las fichas ubicadas para que el sandbox valide
*/
public abstract Tablero ubicarFichas(Ficha[] f,Tablero t);

/**
 * @return retorna un movimiento seleccionado de los tableros creados
 */
public abstract Movimiento jugar();

/**
 * este metodo lo que hace es genera todos los posibles tableros en base a un tablero padre que recibio
 * @param Tablero t
 * @param int Indice de profundidad actual
 * @param int Indice de produndidad maximo
 * 
 */
public abstract boolean generarTableros(Estado estado, int nivelProfunidadActual,int nivelProfunidadMaximo);


/**
 * @param Estado e, recibe un estado y genera los datos con respecto al padre.
 */


protected abstract void generarDatos(Estado estadoNuevo);




/**
 * @param Movimiento m
 * setea el camino recorrido de las fichas en todo el tablero.
 */
protected abstract void setTableroFicha(Movimiento m);


/**
* Metodo para cargar las fichas para el inicio del juego
 * @param t 
 * @param ficha
* Array de fichas que pasa el SandBox al agente
* @param j
* Tipo de jugada
* 1 = Todas las fichas en forma aleatorias
* 2 = Forma ordenada. Se debe cargar el vector "orden" con los valores de
* las fichas. Empieza por la ficha del angulo inferior derecho del tablero del
* jugador. Una vez que llega al extremo sube 1 fila, se empieza a cargar desde
* la primera casilla de la derecha hasta el siguiente extremo. Estos pasos se
* repite sucesibamente hasta cargar las 40 fichas del jugador
* @return
* Retorna el array de fichas con las posiciones para cargar en el tablero
* en forma secuancial
*/
protected abstract Tablero armarTableroInicial(Tablero t, Ficha[] ficha, int j);
public Estado[] getEstados() {
	return estados;
}
public void setEstados(Estado[] estados) {
this.estados = estados;
}
protected SandBoxInterface getSandBoxInterface() {
	return sandBoxInterface;
}
public void setSandBoxInterface(SandBoxInterface sandBoxInterface) {
	this.sandBoxInterface = sandBoxInterface;
}
public void imprimirTablero(Tablero t){
	for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 10; j++) {
			System.out.print(t.getCasillaDelTablero(i, j).getFicha().getValor()+ " ");
		}
		System.out.println();
	}
}
public Ficha[] duplicarFicha ( Ficha[] f) {
    Ficha[] p = new Ficha[40];
    for (int i=0; i<p.length;i++){
        p[i] = f[i];
    }
    return p;
}
public int randomico(int valor){
	Random r=new Random();
	int random=r.nextInt(2)+1;
	return random;
}

}